User interface state transitions

ABSTRACT

Methods and apparatus, including computer program products, are provided for monitoring user interface state transitions. In one aspect, there is provided a method. The method may include monitoring a plurality of operations performed at a user interface; recording, at a cache, the plurality of operations, each of the recorded plurality of operations having a predefined format including a value and a target; moving, in response to a first request to move to a prior state at the user interface, back in the cache to determine the prior state at the user interface; and moving, in response to a second request to move to a subsequent state at the user interface, forward in the cache to determine the subsequent state at the user interface. Related apparatus, systems, methods, and articles are also described.

FIELD

The present disclosure generally relates to data processing and, in particular, user interfaces.

BACKGROUND

User interfaces provide a way to present information and allow interactions between an application and a user. For example, the user interface may be implemented as a browser, a client application, and/or a graphical user interface. The user interface can be used to present data, enter data, and/or provide other interactions with an application. In the age of cloud-based applications, the user interface has become a primary mechanism for the user to interact with a backend application hosted at a server, such as a cloud server.

SUMMARY

Methods and apparatus, including computer program products, are provided for monitoring user interface state transitions.

In one aspect, there is provided a method. The method may include monitoring a plurality of operations performed at a user interface; recording, at a cache, the plurality of operations, each of the recorded plurality of operations having a predefined format including a value and a target; moving, in response to a first request to move to a prior state at the user interface, back in the cache to determine the prior state at the user interface; and moving, in response to a second request to move to a subsequent state at the user interface, forward in the cache to determine the subsequent state at the user interface.

In some implementations, the above-noted aspects may further include additional features described herein including one or more of the following. The controller at the user interface may monitor the plurality of operation being performed. The controller may include a plurality of event listeners at a plurality of user interface elements. The event listener may provide the monitored plurality of operations to the cache. The cache may include an array where the plurality of operations are stored. The target may represent a user interface element, the value being entered into the user interface element. A first operation stored in the cache and a second, subsequent operation stored in the cache may be compress by ignoring and/or deleting the first operation stored in cache, when the first operation does not affect a final value of the corresponding target. The moving back in the cache to determine the prior state at the user interface may occur after the compressing. The moving forward in the cache may occur after the compressing.

It is to be understood that both the foregoing general description and the following detailed description are exemplary and explanatory only and are not restrictive. Further features and/or variations may be provided in addition to those set forth herein. For example, the implementations described herein may be directed to various combinations and subcombinations of the disclosed features and/or combinations and subcombinations of several further features disclosed below in the detailed description.

DESCRIPTION OF THE DRAWINGS

In the drawings,

FIG. 1 depicts an example of a system for monitoring user interface operations, in accordance with some example embodiments;

FIG. 2 depicts an example of a process for monitoring user interface operations, in accordance with some example embodiments; and

FIGS. 3A-3D depict examples of a user interface being monitored, in accordance with some example embodiments.

Like labels are used to refer to same or similar items in the drawings.

DETAILED DESCRIPTION

User interfaces have become increasingly complex and, as such, allow a user to perform relatively complex edits to what is presented via a user interface. Each edit represents a state of the user interface at any given instance in time. Thus, it is becoming increasingly complex to track and move between states at a user interface as the operations performed at the user interface have become increasingly complex. To that end, there is provided a way of monitoring the state of a user interface, in accordance with some example embodiments.

As noted, users may want to perform complicated edits at a user interface. Thus, the user interface may have many states due to these changes or edits. It is quite often the case that a user may want to jump between these states. However, traditional solutions may be inefficient—wasting precious computing and memory resources. The subject matter disclosed herein may provide a way to support efficient monitoring of user interface state transitions. To that end, instead of only storing the final state of a user interface, each of the operations at the user interface may be monitored and recorded. Each operation may be stored in a cache as a record. Each record may include a value and a target associated with the operation. The value may be any type of value or action that is provided or input at the user interface (for example, a numerical value, action such as click, and/or the like). The target may be a target of the operation performed at the user interface such as a user interface element or field at the user interface (e.g., a document object model, control element, text entry field, or other user interface element).

FIG. 1 depicts an example of a system 100 for recording operations at a user interface, in accordance with some example embodiments.

The system 100 may include a user interface 110, such as a browser or other type of user interface that can be generated and presented at a display. For example, the user interface may be a client application, browser, and/or the like associated with a web application 116 or a corresponding cloud-based application 162 accessible via network 150 at server 160. As a change occurs at the user interface 110 due to for example entering data into a user interface element, deleting data from a user interface element, updating data at a user interface element, moving data at the user interface element an element, and/or any other action, the change may represent a state change at the user interface 110. In addition, as noted above, these state changes may be monitored and recorded as records to enable stepping through the records to determine the prior states of the user interface 110.

In the example of FIG. 1, the system may include a processor 190, such as a computer, a tablet, a smartphone, and/or the like, as well as other components, such as a display and the like. The processor 190 may comprise at least one processor and at least one memory including program code, and the processor 190 may include a web application 116 downloaded via a wireless or wired channel from a server 160 via network 150. The web application 116 may be the processor-side portion of a cloud-based service or application 162 hosted at server 160. For example, launching web application 116 may trigger generation of user interface 110, where information can be presented and displayed to enable interaction between application 116 (and/or its user at user interface 110) and the server 160 including application 162.

In some example embodiments, as changes are made to a user interface view (or the user interface elements therein) being displayed at user interface 110, those changes are monitored by user interface (UI) state controller 114. Those changes may then be recorded as records in cache 112. Once recorded, the UI state controller 114 may compress the records in cache 112 by for example combining and/or deleting records. Moreover, the UI state controller 114 may record the records in a predefined format at cache 112. If a back command 122 is received, the UI state controller 114 may provide a prior state of the UI 110 by stepping back to a prior record stored in cache. For example, if operations 1, 2, 3 and so forth are performed at the user interface 110, the UI state controller 114 may record the operations as records at cache 112. In this example, when a back command 122 is received, it triggers UI state controller 114 to step back from operation 3 (which in this example is a current state) to prior operation 2. The moving back may cause the prior state, such as prior state 2, to be displayed at user interface 110 and/or provided as a file to another application, such as web application 116, cloud application 162, and/or the like. While UI state controller 114 is in prior state 2, the selection of the forward command 120 may also cause the UI state controller 114 to move forward in the operations records in cache from state 2 to subsequent state 3, for example. Moreover, this forward step in state may trigger the next state, such as state 3, to be displayed at user interface 110 and/or provided as a file to another application, such as web application 116, cloud application 162, and/or the like.

FIG. 2 depicts an example process 200 for monitoring user interface states, in accordance with some example embodiments. The description of FIG. 2 also refers to FIG. 1.

At 210, operations at a user interface may be monitored. For example, UI state controller 114 may monitor any operations being performed at user interfaces, such as text entry, deletions, selections, mouse clicks, copies, pastes, and/or any other actions including operations. FIG. 3A depicts an example user interface 310 at for example state zero (0). In this example, a text string “slardarOBJ” is input into the user interface element for external code, a text string “name1” is input into the user interface element for external name, and a text string “123” is input into the user interface element for gold. These operations are monitored by UI state controller 114. FIG. 3B depicts user interface 310 at for example state one (1), after a text string “name1” (at FIG. 3A) is changed to “name 2,” which is also monitored by UI state controller 114. In some example embodiments, an event listener may be configured at every user interface element (or its corresponding field such as a drop down selection element or input field of a web page). When this is the case, whenever a value associated with a target user interface element is changed, the event listener may send a notification to the controller 114. Alternatively or additionally, the event listener may format a record for each monitored operation in a predetermined format (which may include a target and value), and then provide that formatted record to the UI state controller 114 and/or cache (where the record can be stored).

In some example embodiments, the UI state controller 114 may monitor atomic operations, which are operations that cannot be subdivided. For example, an atomic operation may comprise entering data into a text input user interface element of a web page. To illustrate further, a user enters “abc” then deletes “c” and later enters “c”. Here, we have 3 atomic operations corresponding to (1) the entry of “abc”, the (2) the deletion of “c” and (3) the re-entry of “c.” Each of these atomic operations may be monitored and formatted in a record that is stored in cache 112. Moreover, the monitoring at 210 may be continuous, periodic, and/or aperiodic so that any operations performed at the user interface are captured as part of the controller's 114 monitoring.

At 212, each operation may be recorded in cache. For example, the UI state controller 114 may record the monitored operations as records at cache 112. In some example embodiments, each monitored operation is recorded as a record having a predetermined format. The predetermined format may include a value field of the operation and a target field. In some example embodiments, the cache 112 is configured as an array. The record (representing the atomic operation, for example) may be accessed via an index that points to a location in the array. Moreover, the cache 112 may be stored in memory along with the browser.

Referring again to FIGS. 3A and 3B, the target of the atomic operation may be the field external name, while the value is (name1, name2), so the record stored in cache 112 takes the following form: externalName (name1, name2). FIG. 3C depicts user interface 310 at for example state two (2), after a text string at the gold field changes from 123 to 1,235. In this example, the target corresponds to the field gold, while the value is (123, 1,235), so the record takes the following form: gold (123, 1,235). FIG. 3D depicts the user interface 310 at state three (3). In state 3, the external name field changes from name2 to name3, so the record takes the following form: externalName (name2, name3). Table 1 below shows a summary of the records that may be stored in cache 112 for the records of the FIG. 3A-3D example.

TABLE 1 State Record 0 AO0: externalCode (slardarOBJ) externalName (name1, name2) gold (123) 1 AO1: externalName (name1, name2) 2 AO2: gold (123, 1,235) 3 AO3: externalName (name2, name3).

The UI state controller 114 may determine whether any of the records should be compressed, in which case UI state controller 114 may combine, ignore, and/or remove one or more records stored in cache 112 (yes at 215 and 220).

Referring to Table 1, there may be a first atomic operation, AO1, and a second, subsequent atomic operation, AO3 and both atomic operations in this example modify the same field, such as external name. In this example, the UI state controller 114 can compress AO1 and AO3 by ignoring AO1. To compress, the UI state controller 114 may remove a record for a given atomic operation if the atomic operation has no effect on the final state. For example, in Table 1, AO1 does not have any effect on final state. Specifically, the final external name will be “name3” because AO3 sets it to “name3” no matter what AO1 sets it to. In fact, AO1 sets it to “name2” but AO3 later overrides that change to “name2” to “name3.” As such, the compression can ignore or delete the record for AO1.

In some example embodiments, the UI state controller 114 may have a configurable compression algorithm. For example, the server 160 may indicate to the UI state controller 114 which compression algorithm to use to reduce the quantity of records for a given session at the user interface. To compress, the UI state controller 114 may process the array of records, and if two atomic operations, such as AOx and AOy, have the same targets and AOy occurs later in time, the earlier atomic operation, AOx, may be ignored. Alternatively or additionally, the user interface 110 may prompt a selection (by for example the user) of a compression algorithm that will be used by the UI state controller 114 to reduce the quantity of records processed for a given session at the user interface. Alternatively or additionally, the web application 116 may select a compression algorithm to use to reduce the quantity of records for a given session at the user interface.

In some example embodiments, the UI state controller 114 may automatically compress by combining AO1 and AO3 (as shown in Table 1, for example) to form a temporary atomic operation record, AO-temp, of the form external field name (name1, name3). In this example, processing yields two AOs: (1) AO2: gold(123, 1,235) and (2) AOtemp: external name(name1, name3). As such, AOtemp can be stored in cache 112 and later rolled back (or undone so to speak).

Referring again to Table 1, it shows four states. In this example, a first selection of the back user interface element 122, triggers the UI state controller to move back (in the cached records of the operations) to a prior state 2; a second selection of the back user interface element 122, triggers the UI state controller to move back to a prior state 1; and a third selection of the back user interface element 122, triggers the UI state controller to move back to a prior state 0.

At 230, the UI state controller 114 may receive a command to move forward. For example, the command may be received from the user interface triggered by a selection of user interface element 120, although the forward command may be received or triggered in other ways (for example, by application 116, application 162, and/or the like). When UI state controller 114 receives the forward command, the UI may move or step forward, at 235, from a given state in the cache to another state. Referring to Table 1, the forward command may trigger the UI state controller 114 to move from state 2 (AO2: gold (123, 1,235)) to state 3 (AO3: externalName (name2, name3)). In this example, the external name would change from name2 to name3 as part of the forward step.

At 240, the UI state controller 114 may receive a command to move back. For example, the command may be received from the user interface triggered by a selection of user interface element 122, although the forward command may be received or triggered in other ways (for example, by application 116, application 162, and/or the like). When UI state controller 114 receives the back command, the UI may move step back, at 245, from a given state in the cache to another state. Referring to Table 1, the back command may trigger the UI state controller 114 to move from state 3 (AO3: externalName (name2, name3)) to state 2 (AO2: gold (123, 1,235)). In this example, the gold field would change from 123 to 1,235 as part of the back step.

Without in any way limiting the scope, interpretation, or application of the claims appearing herein, a technical effect of one or more of the example embodiments disclosed herein may include enhanced monitoring and control of user interface states.

To provide for interaction with a user, the subject matter described herein may be implemented on a computer having a display device (e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor) for displaying information to the user and a keyboard and a pointing device (e.g., a mouse or a trackball) by which the user may provide input to the computer. Other kinds of devices may be used to provide for interaction with a user as well; for example, feedback provided to the user may be any form of sensory feedback (e.g., visual feedback, auditory feedback, or tactile feedback); and input from the user may be received in any form, including acoustic, speech, or tactile input.

The subject matter described herein may be implemented in a computing system that includes a back-end component (e.g., as a data server), or that includes a middleware component (e.g., an application server), or that includes a front-end component (e.g., a client computer having a graphical user interface or a Web browser through which a user may interact with an implementation of the subject matter described herein), or any combination of such back-end, middleware, or front-end components. The components of the system may be interconnected by any form or medium of digital data communication (e.g., a communication network). Examples of communication networks include a local area network (“LAN”), a wide area network (“WAN”), and the Internet.

These computer programs (also known as programs, software, software applications or code) include machine instructions for a programmable processor, and may be implemented in a high-level procedural and/or object-oriented programming language, and/or in assembly/machine language. As used herein, the term “machine-readable medium” refers to any computer program product, apparatus and/or device (e.g., magnetic discs, optical disks, memory, Programmable Logic Devices (PLDs)) used to provide machine instructions and/or data to a programmable processor, including a machine-readable medium that receives machine instructions as a machine-readable signal. The term “machine-readable signal” refers to any signal used to provide machine instructions and/or data to a programmable processor.

The computing system may include clients and servers. A client and server are generally remote from each other and typically interact through a communication network. The relationship of client and server arises by virtue of computer programs running on the respective computers and having a client-server relationship to each other.

Although a few variations have been described in detail above, other modifications are possible. For example, the logic flow depicted in the accompanying figures and described herein does not require the particular order shown, or sequential order, to achieve desirable results. In addition, other processing attributes other than threads can be used to determine whether to selectively change the speed of a core scheduled to process the corresponding tasks. Moreover, the term task can be construed, unless explicitly stated otherwise, to include jobs and other broader groupings of related computing activities. Other embodiments may be within the scope of the following claims. 

What is claimed:
 1. A method comprising: monitoring a plurality of operations performed at a user interface; recording, at a cache, the plurality of operations, each of the recorded plurality of operations having a predefined format including a value and a target; moving, in response to a first request to move to a prior state at the user interface, back in the cache to determine the prior state at the user interface; and moving, in response to a second request to move to a subsequent state at the user interface, forward in the cache to determine the subsequent state at the user interface.
 2. The method of claim 1, wherein a controller at the user interface monitors the plurality of operations being performed.
 3. The method of claim 1, wherein the controller comprises a plurality of event listeners at a plurality of user interface elements.
 4. The method of claim 1 further comprising: providing, by an event listener, the monitored plurality of operations to the cache.
 5. The method of claim 1, wherein the cache comprises an array where the plurality of operations are stored.
 6. The method of claim 1, wherein the target represents a user interface element, the value being entered into the user interface element.
 7. The method of claim 1 further comprising: compressing a first operation stored in the cache and a second, subsequent operation stored in the cache by ignoring and/or deleting the first operation stored in cache, when the first operation does not affect a final value of the corresponding target.
 8. The method of claim 6, wherein the moving back in the cache to determine the prior state at the user interface occurs after the compressing.
 9. The method of claim 6, wherein the moving forward in the cache occurs after the compressing.
 10. A system comprising: at least one processor; and at least one memory including program code which when executed by the at least one processor causes operations comprising: monitoring a plurality of operations performed at a user interface; recording, at a cache, the plurality of operations, each of the recorded plurality of operations having a predefined format including a value and a target; moving, in response to a first request to move to a prior state at the user interface, back in the cache to determine the prior state at the user interface; and moving, in response to a second request to move to a subsequent state at the user interface, forward in the cache to determine the subsequent state at the user interface.
 11. The system of claim 10, wherein a controller at the user interface monitors the plurality of operations being performed.
 12. The system of claim 10, wherein the controller comprises a plurality of event listeners at a plurality of user interface elements.
 13. The system of claim 10 further comprising: providing, by an event listener, the monitored plurality of operations to the cache.
 14. The system of claim 10, wherein the cache comprises an array where the plurality of operations are stored.
 15. The system of claim 10, wherein the target represents a user interface element, the value being entered into the user interface element.
 16. The system of claim 10 further comprising: compressing a first operation stored in the cache and a second, subsequent operation stored in the cache by ignoring and/or deleting the first operation stored in cache, when the first operation does not affect a final value of the corresponding target.
 17. The system of claim 16, wherein the moving back in the cache to determine the prior state at the user interface occurs after the compressing.
 18. The system of claim 16, wherein the moving forward in the cache occurs after the compressing.
 19. A non-transitory computer-readable program medium including program code which executed by the at least one processor causes operations comprising: monitoring a plurality of operations performed at a user interface; recording, at a cache, the plurality of operations, each of the recorded plurality of operations having a predefined format including a value and a target; moving, in response to a first request to move to a prior state at the user interface, back in the cache to determine the prior state at the user interface; and moving, in response to a second request to move to a subsequent state at the user interface, forward in the cache to determine the subsequent state at the user interface. 